// app/controller/reconciliation_result_controller.js
'use strict';

const Controller = require('egg').Controller;

class ReconciliationResultController extends Controller {
  // 获取对账结果列表
  async index() {
    const { ctx } = this;
    const { page = 1, pageSize = 10, matchStatus, minConfidence, maxConfidence } = ctx.query;
    
    try {
      // 使用Joi验证服务进行参数验证
      const validation = ctx.service.validationService.validateId(page);
      if (validation.error) {
        ctx.error(`参数验证失败: ${validation.error.message}`);
        return;
      }
      
      const query = {
        where: {},
        include: [
          {
            model: ctx.model.SalesOrderModel,
            as: 'salesOrder',
            attributes: ['id', 'platformOrderId', 'orderAmount', 'orderDate']
          },
          {
            model: ctx.model.BankTransactionModel,
            as: 'bankTransaction',
            attributes: ['id', 'transactionId', 'payerName', 'amount', 'transactionDate']
          }
        ]
      };
      
      if (matchStatus) {
        query.where.matchStatus = matchStatus;
      }
      
      if (minConfidence || maxConfidence) {
        query.where.matchConfidence = {};
        
        if (minConfidence) {
          query.where.matchConfidence[ctx.app.Sequelize.Op.gte] = parseFloat(minConfidence);
        }
        
        if (maxConfidence) {
          query.where.matchConfidence[ctx.app.Sequelize.Op.lte] = parseFloat(maxConfidence);
        }
      }
      
      const result = await ctx.model.ReconciliationResultModel.findAndCountAll({
        ...query,
        limit: parseInt(pageSize),
        offset: (parseInt(page) - 1) * parseInt(pageSize),
        order: [['matched_at', 'DESC']]
      });
      
      ctx.page(result.rows, result.count, parseInt(page), parseInt(pageSize));
    } catch (error) {
      ctx.logger.error('获取对账结果列表失败:', error);
      ctx.error('获取对账结果列表失败');
    }
  }
  
  // 获取对账结果详情
  async show() {
    const { ctx } = this;
    const { id } = ctx.params;
    
    try {
      // 使用Joi验证服务进行参数验证
      const validation = ctx.service.validationService.validateId(id);
      if (validation.error) {
        ctx.error(`参数验证失败: ${validation.error.message}`);
        return;
      }
      
      const result = await ctx.model.ReconciliationResultModel.findByPk(id, {
        include: [
          {
            model: ctx.model.SalesOrderModel,
            as: 'salesOrder'
          },
          {
            model: ctx.model.BankTransactionModel,
            as: 'bankTransaction'
          }
        ]
      });
      
      if (!result) {
        ctx.error('对账结果不存在', 404);
        return;
      }
      
      ctx.success(result);
    } catch (error) {
      ctx.logger.error('获取对账结果详情失败:', error);
      ctx.error('获取对账结果详情失败');
    }
  }
  
  // 创建对账结果
  async create() {
    const { ctx } = this;
    
    try {
      // 使用Joi验证服务进行参数验证
      const validation = ctx.service.validationService.validateCreateReconciliationResult(ctx.request.body);
      if (validation.error) {
        ctx.error(`参数验证失败: ${validation.error.message}`);
        return;
      }
      
      const result = await ctx.model.ReconciliationResultModel.create(ctx.request.body);
      ctx.success(result, '对账结果创建成功');
    } catch (error) {
      ctx.logger.error('创建对账结果失败:', error);
      ctx.error('创建对账结果失败');
    }
  }
  
  // 更新对账结果
  async update() {
    const { ctx } = this;
    const { id } = ctx.params;
    
    try {
      // 使用Joi验证服务进行参数验证
      const idValidation = ctx.service.validationService.validateId(id);
      if (idValidation.error) {
        ctx.error(`参数验证失败: ${idValidation.error.message}`);
        return;
      }
      
      const validation = ctx.service.validationService.validateUpdateReconciliationResult(ctx.request.body);
      if (validation.error) {
        ctx.error(`参数验证失败: ${validation.error.message}`);
        return;
      }
      
      const result = await ctx.model.ReconciliationResultModel.findByPk(id);
      
      if (!result) {
        ctx.error('对账结果不存在', 404);
        return;
      }
      
      await result.update(ctx.request.body);
      ctx.success(result, '对账结果更新成功');
    } catch (error) {
      ctx.logger.error('更新对账结果失败:', error);
      ctx.error('更新对账结果失败');
    }
  }
  
  // 删除对账结果
  async destroy() {
    const { ctx } = this;
    const { id } = ctx.params;
    
    try {
      // 使用Joi验证服务进行参数验证
      const validation = ctx.service.validationService.validateId(id);
      if (validation.error) {
        ctx.error(`参数验证失败: ${validation.error.message}`);
        return;
      }
      
      const result = await ctx.model.ReconciliationResultModel.findByPk(id);
      
      if (!result) {
        ctx.error('对账结果不存在', 404);
        return;
      }
      
      await result.destroy();
      ctx.success(null, '对账结果删除成功');
    } catch (error) {
      ctx.logger.error('删除对账结果失败:', error);
      ctx.error('删除对账结果失败');
    }
  }
  
  // 确认对账结果
  async confirm() {
    const { ctx } = this;
    const { id } = ctx.params;
    const { confirmedBy } = ctx.request.body;
    
    try {
      // 使用Joi验证服务进行参数验证
      const idValidation = ctx.service.validationService.validateId(id);
      if (idValidation.error) {
        ctx.error(`参数验证失败: ${idValidation.error.message}`);
        return;
      }
      
      const result = await ctx.model.ReconciliationResultModel.findByPk(id);
      
      if (!result) {
        ctx.error('对账结果不存在', 404);
        return;
      }
      
      await result.update({
        matchStatus: 'confirmed',
        confirmedBy: confirmedBy,
        confirmedAt: new Date()
      });
      
      ctx.success(result, '对账结果确认成功');
    } catch (error) {
      ctx.logger.error('确认对账结果失败:', error);
      ctx.error('确认对账结果失败');
    }
  }
  
  // 拒绝对账结果
  async reject() {
    const { ctx } = this;
    const { id } = ctx.params;
    const { notes } = ctx.request.body;
    
    try {
      // 使用Joi验证服务进行参数验证
      const idValidation = ctx.service.validationService.validateId(id);
      if (idValidation.error) {
        ctx.error(`参数验证失败: ${idValidation.error.message}`);
        return;
      }
      
      const result = await ctx.model.ReconciliationResultModel.findByPk(id);
      
      if (!result) {
        ctx.error('对账结果不存在', 404);
        return;
      }
      
      await result.update({
        matchStatus: 'rejected',
        notes: notes
      });
      
      ctx.success(result, '对账结果拒绝成功');
    } catch (error) {
      ctx.logger.error('拒绝对账结果失败:', error);
      ctx.error('拒绝对账结果失败');
    }
  }
}

module.exports = ReconciliationResultController;